""" 什么是列表"""

"""
为了使程序能方便地存储和操作数据,Python语言提供了一些内置的数据结构,
例如:列表、元组、字典和集合等。所谓"内置",指的是它们是Python语言的一部分,
因此在程序中可以直接使用它们,

一、列表的示意图
    列表相当于其它编程语言中的数组。
二、列表的特点
    1.列表中的所有数据是按顺序有序排列的,也就是说,列表属于于序列类型
    2.列表中的所有数据都有两个整数类型的索引,通过指定的索引引总能映射到唯一确定的数据;
    3.列表中可以存在重复的数据
    4.列表中可以保存任何类型的数据,多种类型的数据可以以混合存储在一个列表中;
    5.列表可以根据需要动态地伸缩,也就是说,系统会根据需要动态地分配和回收内存,因此,在使用前无须预先声明列表的容量。
"""


# 创建列表
def chuangjian():
    # 1.中括号创建
    L = ['Python', 18, True]
    print(L)
    # 空列表
    print([])
    # 2.调用list函数()
    print(list(range(1, 6)))  # [1, 2, 3, 4, 5]
    print(list(['Python', 18, True]))  # ['Python', 18, True]
    # 空列表
    print(list())  # []


# chuangjian()

"""
一、列表中元素的索引
列表中的每个元素都有两个整数类型的索引:
1.第1个元素的索引是0,后面元素的索引依次递增1;
2.最后一个元素的索引是-1,前面元素的索引依次递减1。
"""


# 列表的查操作之获得指定元素的索引
def huoqusuoyi():
    L = [5, 5, 7, 9, 2, 1, 7, 6]
    print(L.index(5))  # 0
    print(L.index(7))  # 2
    # print(L.index(8)) # 8 is not in list

    # 调用方法index时还可以指定起始索引start和结束索引stop这两个参数。
    print(L.index(7, 3))  # 6
    print(L.index(7, 3, 5))  # 7 is not in list


# huoqusuoyi()

# 获取列表中一个的元素
def huoquyuansu():
    L = [5, 3, 6, 9, 4, 0, 6, 8, 1, 7, 2]
    print(len(L))  # 11
    print(L[-11])  # 5
    print(L[0])  # 5
    print(L[6])  # 6

    # 索引不存在，会抛出IndeError
    # print(L[11]) #IndexError: list index out of range


# huoquyuansu()


"""
    可以使用切片获得列表中的元素,一次可以获得多个元素。
    切片的语法格式:[start:stop:step],其中,
1.得到的切片仍然是列表,是原始列表的片段的一份拷贝。
2.得到的切片不包括索引stop对应的元素。
3.如果不指定step,其默认值是1,此时语法格式可以简化为@[start:stop]
4.当step为正数时,
    如果不指定start,切片的第一个元素默认是表的第一个元素。
    如果不指定stop,切片的最后一个元素默认是列表的最后一个个元素。
    从索引start开始往后计算切片。
当step为负数时,
    如果不指定start,切片的第一个元素默认是列表的最后一个个元素。
    如果不指定stop,切片的最后一个元素默认是列表的第一个元素。
    从索引start开始往前计算切片。
"""


# '列表的"查"操作之使用切片一次获得多个元素
def huoquqiepianyuansu():
    L = [5, 3, 7, 9, 2, 1, 7, 6]  # len 8
    print(L[1:len(L):1])  # [3, 7, 9, 2, 1, 7, 6]
    print(L[1:7:1])  # [3, 7, 9, 2, 1, 7, 6]
    print(L[-len(L):-2])  # [5, 3, 7, 9, 2, 1]

    print(L[::])  # [5, 3, 7, 9, 2, 1, 7, 6]
    # step为负数，列表反转
    print(L[::-1])  # [6, 7, 1, 2, 9, 7, 3, 5]

    # 切片操作允许越界
    print(L[:100])  # [5, 3, 7, 9, 2, 1, 7, 6]
    # print(L[-100:]) #[5, 3, 7, 9, 2, 1, 7, 6]
    """
        可以调用slice内置函数可以调用内置函数slice(类slice的构造方法)创建slice类型的对象
        内置函数slice有三种调用方式:
        1. slice(stop)
        2. slice(start, stop)
        3. slice(start, stop, step)
        start、stop和step的默认值都是None。
        slice(start,stop,step)与start:stop:step是等价的。
    """
    print(L[1:4:2])  # [3, 9]
    print(L[slice(1, 4, 2)])  # [3, 9]

    print(L[::])  # [5, 3, 7, 9, 2, 1, 7, 6]
    print(L[slice(None, None, None)])  # [5, 3, 7, 9, 2, 1, 7, 6]

    print(L[1:7])  # [3, 7, 9, 2, 1, 7]
    print(L[slice(1, 7)])  # [3, 7, 9, 2, 1, 7]
    print(L[slice(1, 7, None)])  # [3, 7, 9, 2, 1, 7]


# huoquqiepianyuansu() #[6, 7, 1, 2, 9, 7, 3, 5]

"""列表的"查"操作之使用运算符in检查是否存在指定元素"""
"""
    可以使用运算符in检查列表中是否存在指定元素。
    如果存在,返回True;如果不存在,返回False
"""


def cunzai_in():
    L = [3, 4, 5, 6, 7]
    print(3 in L)  # True
    print(8 in L)  # False

    print(3 not in L)
    print(8 not in L)


# cunzai_in()


"""列表修改操作"""


def list_modify():
    L = [3, 4, 5, 6, 7]
    L[2] = 8
    print(L)  # [3, 4, 8, 6, 7]
    L[1:4] = [1, 9, 2]  # [3, 1, 9, 2, 7]
    print(L)


# list_modify()

"""列表加"""


# 如果想往列表中添加元素,有四种常见的方式:
# 一、调用方法append(在列表的末尾一次只添加一个元素)
def liebiao_add():
    L = [3, 4, 5, 6, 7]
    L.append(14)
    print(L)  # [3, 4, 5, 6, 7, 14]

    L.append([9, 10])
    print(L)  # 3, 4, 5, 6, 7, 14, [9, 10]]

    """
    二、调用方法extend(在列表的未尾一次至少添加一个元素)
    将参数中的所有元素依次添加到列表的末尾。
    """
    L = [3, 4, 5, 6, 7]
    L.extend([9, 10])
    print(L)  # [3, 4, 5, 6, 7, 9, 10]

    """
    三、调用方法insert(在列表的任意位置一次只添加一个元素)
    
    """
    L = [3, 4, 5, 6, 7]
    L.insert(4, 8)
    print(L)  # [3, 4, 5, 6, 8, 7]
    L.insert(len(L), 11)
    print(L)  # [3, 4, 5, 6, 8, 7, 11]
    """
    四、为指定的切片赋予一个新值(在列表的任意位置一次至少添加一个元素)
    """
    L = [3, 4, 5, 6]
    L[2:2] = [8, 9]
    print(L)  # [3, 4, 8, 9, 5, 6]
    L[len(L):] = [1, 2]
    print(L)


# liebiao_add()

"""
列表删除操作,
如果想要删除列表中的元素,有五种常见的方式:
一、调用方法remove(一次只删除一个指定的元素)
被删除元素后面的所有元素依次前移一个位置。
"""


def liebiao_remove():
    L = [3, 4, 5, 6]
    L.remove(5)
    print(L)  # [3, 4, 6]

    # 如果列表中存在多个指定元素, 只删除第1个指定元素。
    L = [3, 5, 4, 5, 6]
    L.remove(5)
    print(L)  # [3, 4, 5, 6]

    # 如果要删除的指定元素在列表中不存在, 抛出ValueError。
    # L.remove(8) #ValueError: list.remove(x): x not in list
    """
    二、调用方法pop(一次只删除一个指定索引的元素)
    该方法返回被删除的元素。
    """
    L = [3, 4, 5, 6, 7]
    print(L.pop(2))  # 5
    print(L)  # [3, 4, 6, 7]
    """
    如果指定的索引不存在,抛出IndexError。
    """
    # L.pop(8) # IndexError: pop index out of range

    """
    如果没有指定索引,默认删除列表中的最后一个元素。
    """
    print(L.pop())  # 7
    print(L)  # [3, 4, 6]

    """
    使用del语句(一次至少删除一个元素)
    """
    L = [3, 4, 5, 6, 7, 8, 9]
    del L[2]
    print(L)  # [3, 4, 6, 7, 8, 9]

    del L[1:4]
    print(L)  # [3, 8, 9]

    """
    四、给指定的切片赋值一个空列表(一次至少删除一个元素)
    """
    L = [3, 4, 5, 6, 7, 8, 9]
    L[2:3] = []
    print(L)  # [3, 4, 6, 7, 8, 9]
    L[1:4] = []
    print(L)  # [3, 8, 9]

    # 清空列表
    L[:] = []
    print(L)  # []

    """
    五、调用方法clear清空列表
    """
    L = [3, 4, 5, 6, 7, 8, 9]
    L.clear()
    print(L)  # []


# liebiao_remove()

"""
使用加法运算符操作列表
"""

"""

"""


def add_mul():
    L1 = [1, 2, 3]
    L2 = [4, 5, 6]
    L3 = L1 + L2
    print(L3)  # [1, 2, 3, 4, 5, 6]

    """
    参数赋值运算符+=会对列表本身进行修改。
    """
    L1 = L2 = [1, 2]
    L1 = L1 + [3, 4]
    print(L1, L2)  # [1, 2, 3, 4] [1, 2]

    L1 = L2 = [1, 2]
    L1 += [3, 4]
    print(L1, L2)  # [1, 2, 3, 4] [1, 2, 3, 4]

    """
    二、使用惩罚运算符操作列表
    可以使用乘法运算符将列表中的所有元素重复n次后生成一个新列表,被乘的列表不发生任何变化。
    """
    L1 = [1, 2, 3]
    L = L1 * 3
    print(L)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
    print(L1)  # [1, 2, 3]

    """
    数赋值运算符*=会对列表本身进行修改。
    """
    L1 = L2 = [1, 2]
    L1 *= 2
    print(L1, L2)  # [1, 2, 1, 2] [1, 2, 1, 2]


# add_mul()


"""使用比较运算符比较两个列表"""
"""
>
>=
<
<=
==
!=
比较规则为:首先比较两个列表中的第一个元素,如果相等则继续比较下一个元素,依次比较下去,
直到两个列表中的元素不相等时其比较结果就是两个列表的比较交结果,两个列表中的所有后续元素将
不再被比较。
"""


def compare_list():
    print([2, 3, 5, 6, 7] < [2, 3, 9, 5, 1])  # True
    print([7, [2, 6]] > [7, [2, 5]])  # True

    """
    
    还可以使用is对两个列表进行比较。
    ==与is的区别:==是"相等性"测试,is是"同一性"测试。
    """
    a = b = [1, 2, 3]
    c = [1, 2, 3]
    print(a == b)  # True
    print(a == c)  # True
    print(a is b)  # True
    print(a is c)  # False


# compare_list()

"""
列表的反转
"""

"""
如果想对列表中的所有元素进行反转,常见的方式有两种:
一、调用方法reverse
"""


def fanzhaun_list():
    L = [1, 2, 3, 4, 5]
    L.reverse()
    print(L) #[5, 4, 3, 2, 1]

    """
    调用内置函数reversed
    内置函数reversed的返回值是一个迭代器对象,且被反转的列表不发生变化。
    """
    L = [1, 2, 3, 4, 5]
    iterator = reversed(L)
    print(iterator) #<list_reverseiterator object at 0x00000251387E3FD0>
    print(list(iterator)) #[5, 4, 3, 2, 1]
    print(iterator) #<list_reverseiterator object at 0x00000251387E3FD0>

# fanzhaun_list()

"""列表的排序"""

"""
如果想对列表中的所有元素进行排序,常见的方式有两种:
一、调用方法sort
调用方法sort后,列表中的所有元素默认按照从小到大的顺序进行了排序。
"""
def sort_list():
    L = [5, 3, 8, 1, 6]
    L.sort()
    print(L) # [1, 3, 5, 6, 8]

    L.sort(reverse=True)
    print(L) # [8, 6, 5, 3, 1]

    """
    二、调用内置函数sorted
    内置函数sorted的返回值是排序后生成的新列表,且被排序序的列表不发生变化。
    """
    L = [5, 3, 8, 1, 6]
    print(sorted(L)) #[1, 3, 5, 6, 8]
    print(L) #[5, 3, 8, 1, 6]

    print(sorted(L,reverse=True)) #[8, 6, 5, 3, 1]
    print(L) # [5, 3, 8, 1, 6]
# sort_list()

"""多维列表"""

"""
当列表中的元素也是列表时,就构成了多维列表。例如:当列表中的元素是一维列表时,就构成了
二维列表;当列表中的元素是二维列表时,就构成了三维列表。因此,可以把多维列表看做是特殊的
一维列表。
一、一维列表的操作也适用于多维列表
"""

def duowei_list():
    L = [[3,4],[1,5,2],[6,8,9,7]]

    print(L[2][1]) # 8

    L[1] = 9
    print(L) #[[3, 4], 9, [6, 8, 9, 7]]

    L.append([2,3])
    print(L) #[[3, 4], 9, [6, 8, 9, 7], [2, 3]]

    L.pop(2)
    print(L) # [[3, 4], 9, [2, 3]]

    """
    二、多维列表的初始化
    """
    print([[0] * 3] * 4) #[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

    print([[0 for i in range(3)] for j in range(4)]) #[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
    L = list(range(1,6))
    print(L)
    print(L.index(2))
    print(L[::])
duowei_list()
if __name__ == "__main__":
    print()
